// $ANTLR 3.2 Sep 23, 2009 12:02:23 C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g 2009-12-05 13:31:25

// The variable 'variable' is assigned but its value is never used.
#pragma warning disable 168, 219
// Unreachable code detected.
#pragma warning disable 162


using System;
using Antlr.Runtime;
using USU.MetricsMonitor.DiffParser;
using IList 		= System.Collections.IList;
using ArrayList 	= System.Collections.ArrayList;
using Stack 		= Antlr.Runtime.Collections.StackList;


namespace DiffParser.impl
{
public partial class diffParser : Parser
{
    public static readonly string[] tokenNames = new string[] 
	{
        "<invalid>", 
		"<EOR>", 
		"<DOWN>", 
		"<UP>", 
		"INDEX", 
		"SPACE", 
		"CRLF", 
		"SEPARATOR", 
		"PROP_CH", 
		"PROP_SEP", 
		"PLUS", 
		"MINUS", 
		"NNL", 
		"ATS", 
		"COMMA", 
		"CD", 
		"TAB", 
		"LB", 
		"REVISION", 
		"DIGIT", 
		"RB", 
		"WORKING_COPY", 
		"CHAR"
    };

    public const int PROP_SEP = 9;
    public const int RB = 20;
    public const int CRLF = 6;
    public const int CHAR = 22;
    public const int TAB = 16;
    public const int SEPARATOR = 7;
    public const int MINUS = 11;
    public const int REVISION = 18;
    public const int SPACE = 5;
    public const int EOF = -1;
    public const int ATS = 13;
    public const int INDEX = 4;
    public const int COMMA = 14;
    public const int NNL = 12;
    public const int PROP_CH = 8;
    public const int WORKING_COPY = 21;
    public const int PLUS = 10;
    public const int LB = 17;
    public const int DIGIT = 19;
    public const int CD = 15;

    // delegates
    // delegators



        public diffParser(ITokenStream input)
    		: this(input, new RecognizerSharedState()) {
        }

        public diffParser(ITokenStream input, RecognizerSharedState state)
    		: base(input, state) {
            InitializeCyclicDFAs();

             
        }
        

    override public string[] TokenNames {
		get { return diffParser.tokenNames; }
    }

    override public string GrammarFileName {
		get { return "C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g"; }
    }


    	private DiffProcessor proc;
    	private String fileName, newFileName, oldFileName;
    	private Range curRange, oldRange, newRange;
    	public diffParser(ITokenStream input, DiffProcessor processor) : this(input) { proc = processor; }



    // $ANTLR start "diff"
    // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:13:1: diff : ( file | prop )* ;
    public void diff() // throws RecognitionException [1]
    {   
        try 
    	{
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:13:7: ( ( file | prop )* )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:13:9: ( file | prop )*
            {
            	// C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:13:9: ( file | prop )*
            	do 
            	{
            	    int alt1 = 3;
            	    int LA1_0 = input.LA(1);

            	    if ( (LA1_0 == INDEX) )
            	    {
            	        alt1 = 1;
            	    }
            	    else if ( (LA1_0 == CRLF) )
            	    {
            	        alt1 = 2;
            	    }


            	    switch (alt1) 
            		{
            			case 1 :
            			    // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:13:10: file
            			    {
            			    	PushFollow(FOLLOW_file_in_diff34);
            			    	file();
            			    	state.followingStackPointer--;


            			    }
            			    break;
            			case 2 :
            			    // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:13:15: prop
            			    {
            			    	PushFollow(FOLLOW_prop_in_diff36);
            			    	prop();
            			    	state.followingStackPointer--;


            			    }
            			    break;

            			default:
            			    goto loop1;
            	    }
            	} while (true);

            	loop1:
            		;	// Stops C# compiler whining that label 'loop1' has no statements


            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return ;
    }
    // $ANTLR end "diff"


    // $ANTLR start "file"
    // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:14:1: file : ( INDEX SPACE path CRLF SEPARATOR CRLF ) ( ( file_header ( hunk )+ ) | cannot_display ) ;
    public void file() // throws RecognitionException [1]
    {   
        diffParser.path_return path1 = default(diffParser.path_return);


        try 
    	{
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:14:7: ( ( INDEX SPACE path CRLF SEPARATOR CRLF ) ( ( file_header ( hunk )+ ) | cannot_display ) )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:14:9: ( INDEX SPACE path CRLF SEPARATOR CRLF ) ( ( file_header ( hunk )+ ) | cannot_display )
            {
            	// C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:14:9: ( INDEX SPACE path CRLF SEPARATOR CRLF )
            	// C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:14:10: INDEX SPACE path CRLF SEPARATOR CRLF
            	{
            		Match(input,INDEX,FOLLOW_INDEX_in_file47); 
            		Match(input,SPACE,FOLLOW_SPACE_in_file49); 
            		PushFollow(FOLLOW_path_in_file51);
            		path1 = path();
            		state.followingStackPointer--;

            		fileName = ((path1 != null) ? input.ToString((IToken)(path1.Start),(IToken)(path1.Stop)) : null);
            		Match(input,CRLF,FOLLOW_CRLF_in_file55); 
            		Match(input,SEPARATOR,FOLLOW_SEPARATOR_in_file57); 
            		Match(input,CRLF,FOLLOW_CRLF_in_file59); 

            	}

            	// C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:15:5: ( ( file_header ( hunk )+ ) | cannot_display )
            	int alt3 = 2;
            	int LA3_0 = input.LA(1);

            	if ( (LA3_0 == MINUS) )
            	{
            	    alt3 = 1;
            	}
            	else if ( (LA3_0 == CD) )
            	{
            	    alt3 = 2;
            	}
            	else 
            	{
            	    NoViableAltException nvae_d3s0 =
            	        new NoViableAltException("", 3, 0, input);

            	    throw nvae_d3s0;
            	}
            	switch (alt3) 
            	{
            	    case 1 :
            	        // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:15:6: ( file_header ( hunk )+ )
            	        {
            	        	// C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:15:6: ( file_header ( hunk )+ )
            	        	// C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:15:7: file_header ( hunk )+
            	        	{
            	        		PushFollow(FOLLOW_file_header_in_file68);
            	        		file_header();
            	        		state.followingStackPointer--;

            	        		// C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:15:19: ( hunk )+
            	        		int cnt2 = 0;
            	        		do 
            	        		{
            	        		    int alt2 = 2;
            	        		    int LA2_0 = input.LA(1);

            	        		    if ( (LA2_0 == ATS) )
            	        		    {
            	        		        alt2 = 1;
            	        		    }


            	        		    switch (alt2) 
            	        			{
            	        				case 1 :
            	        				    // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:15:19: hunk
            	        				    {
            	        				    	PushFollow(FOLLOW_hunk_in_file70);
            	        				    	hunk();
            	        				    	state.followingStackPointer--;


            	        				    }
            	        				    break;

            	        				default:
            	        				    if ( cnt2 >= 1 ) goto loop2;
            	        			            EarlyExitException eee2 =
            	        			                new EarlyExitException(2, input);
            	        			            throw eee2;
            	        		    }
            	        		    cnt2++;
            	        		} while (true);

            	        		loop2:
            	        			;	// Stops C# compiler whining that label 'loop2' has no statements


            	        	}


            	        }
            	        break;
            	    case 2 :
            	        // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:15:28: cannot_display
            	        {
            	        	PushFollow(FOLLOW_cannot_display_in_file76);
            	        	cannot_display();
            	        	state.followingStackPointer--;


            	        }
            	        break;

            	}


            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return ;
    }
    // $ANTLR end "file"


    // $ANTLR start "prop"
    // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:17:1: prop : CRLF PROP_CH SPACE path CRLF PROP_SEP CRLF ( ( nonindex ( anytoken )* ) CRLF )* ( CRLF )+ ;
    public void prop() // throws RecognitionException [1]
    {   
        try 
    	{
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:17:7: ( CRLF PROP_CH SPACE path CRLF PROP_SEP CRLF ( ( nonindex ( anytoken )* ) CRLF )* ( CRLF )+ )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:17:9: CRLF PROP_CH SPACE path CRLF PROP_SEP CRLF ( ( nonindex ( anytoken )* ) CRLF )* ( CRLF )+
            {
            	Match(input,CRLF,FOLLOW_CRLF_in_prop90); 
            	Match(input,PROP_CH,FOLLOW_PROP_CH_in_prop92); 
            	Match(input,SPACE,FOLLOW_SPACE_in_prop94); 
            	PushFollow(FOLLOW_path_in_prop96);
            	path();
            	state.followingStackPointer--;

            	Match(input,CRLF,FOLLOW_CRLF_in_prop98); 
            	Match(input,PROP_SEP,FOLLOW_PROP_SEP_in_prop100); 
            	Match(input,CRLF,FOLLOW_CRLF_in_prop102); 
            	// C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:17:52: ( ( nonindex ( anytoken )* ) CRLF )*
            	do 
            	{
            	    int alt5 = 2;
            	    int LA5_0 = input.LA(1);

            	    if ( (LA5_0 == SPACE || (LA5_0 >= SEPARATOR && LA5_0 <= CHAR)) )
            	    {
            	        alt5 = 1;
            	    }


            	    switch (alt5) 
            		{
            			case 1 :
            			    // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:17:53: ( nonindex ( anytoken )* ) CRLF
            			    {
            			    	// C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:17:53: ( nonindex ( anytoken )* )
            			    	// C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:17:54: nonindex ( anytoken )*
            			    	{
            			    		PushFollow(FOLLOW_nonindex_in_prop106);
            			    		nonindex();
            			    		state.followingStackPointer--;

            			    		// C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:17:63: ( anytoken )*
            			    		do 
            			    		{
            			    		    int alt4 = 2;
            			    		    int LA4_0 = input.LA(1);

            			    		    if ( ((LA4_0 >= INDEX && LA4_0 <= SPACE) || (LA4_0 >= SEPARATOR && LA4_0 <= CHAR)) )
            			    		    {
            			    		        alt4 = 1;
            			    		    }


            			    		    switch (alt4) 
            			    			{
            			    				case 1 :
            			    				    // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:17:63: anytoken
            			    				    {
            			    				    	PushFollow(FOLLOW_anytoken_in_prop108);
            			    				    	anytoken();
            			    				    	state.followingStackPointer--;


            			    				    }
            			    				    break;

            			    				default:
            			    				    goto loop4;
            			    		    }
            			    		} while (true);

            			    		loop4:
            			    			;	// Stops C# compiler whining that label 'loop4' has no statements


            			    	}

            			    	Match(input,CRLF,FOLLOW_CRLF_in_prop111); 

            			    }
            			    break;

            			default:
            			    goto loop5;
            	    }
            	} while (true);

            	loop5:
            		;	// Stops C# compiler whining that label 'loop5' has no statements

            	// C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:17:80: ( CRLF )+
            	int cnt6 = 0;
            	do 
            	{
            	    int alt6 = 2;
            	    int LA6_0 = input.LA(1);

            	    if ( (LA6_0 == CRLF) )
            	    {
            	        int LA6_2 = input.LA(2);

            	        if ( (LA6_2 == EOF || LA6_2 == INDEX || LA6_2 == CRLF) )
            	        {
            	            alt6 = 1;
            	        }


            	    }


            	    switch (alt6) 
            		{
            			case 1 :
            			    // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:17:80: CRLF
            			    {
            			    	Match(input,CRLF,FOLLOW_CRLF_in_prop115); 

            			    }
            			    break;

            			default:
            			    if ( cnt6 >= 1 ) goto loop6;
            		            EarlyExitException eee6 =
            		                new EarlyExitException(6, input);
            		            throw eee6;
            	    }
            	    cnt6++;
            	} while (true);

            	loop6:
            		;	// Stops C# compiler whining that label 'loop6' has no statements


            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return ;
    }
    // $ANTLR end "prop"


    // $ANTLR start "hunk"
    // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:18:1: hunk : hunk_header ( line )+ ;
    public void hunk() // throws RecognitionException [1]
    {   
        try 
    	{
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:18:7: ( hunk_header ( line )+ )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:18:9: hunk_header ( line )+
            {
            	PushFollow(FOLLOW_hunk_header_in_hunk124);
            	hunk_header();
            	state.followingStackPointer--;

            	// C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:18:21: ( line )+
            	int cnt7 = 0;
            	do 
            	{
            	    int alt7 = 2;
            	    int LA7_0 = input.LA(1);

            	    if ( (LA7_0 == SPACE || (LA7_0 >= PLUS && LA7_0 <= NNL)) )
            	    {
            	        alt7 = 1;
            	    }


            	    switch (alt7) 
            		{
            			case 1 :
            			    // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:18:21: line
            			    {
            			    	PushFollow(FOLLOW_line_in_hunk126);
            			    	line();
            			    	state.followingStackPointer--;


            			    }
            			    break;

            			default:
            			    if ( cnt7 >= 1 ) goto loop7;
            		            EarlyExitException eee7 =
            		                new EarlyExitException(7, input);
            		            throw eee7;
            	    }
            	    cnt7++;
            	} while (true);

            	loop7:
            		;	// Stops C# compiler whining that label 'loop7' has no statements

            	proc.HunkEndHandler();

            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return ;
    }
    // $ANTLR end "hunk"


    // $ANTLR start "line"
    // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:20:1: line : ( context_line | added_line | removed_line | no_newline ) CRLF ;
    public void line() // throws RecognitionException [1]
    {   
        try 
    	{
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:20:7: ( ( context_line | added_line | removed_line | no_newline ) CRLF )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:20:9: ( context_line | added_line | removed_line | no_newline ) CRLF
            {
            	// C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:20:9: ( context_line | added_line | removed_line | no_newline )
            	int alt8 = 4;
            	switch ( input.LA(1) ) 
            	{
            	case SPACE:
            		{
            	    alt8 = 1;
            	    }
            	    break;
            	case PLUS:
            		{
            	    alt8 = 2;
            	    }
            	    break;
            	case MINUS:
            		{
            	    alt8 = 3;
            	    }
            	    break;
            	case NNL:
            		{
            	    alt8 = 4;
            	    }
            	    break;
            		default:
            		    NoViableAltException nvae_d8s0 =
            		        new NoViableAltException("", 8, 0, input);

            		    throw nvae_d8s0;
            	}

            	switch (alt8) 
            	{
            	    case 1 :
            	        // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:20:10: context_line
            	        {
            	        	PushFollow(FOLLOW_context_line_in_line139);
            	        	context_line();
            	        	state.followingStackPointer--;


            	        }
            	        break;
            	    case 2 :
            	        // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:20:25: added_line
            	        {
            	        	PushFollow(FOLLOW_added_line_in_line143);
            	        	added_line();
            	        	state.followingStackPointer--;


            	        }
            	        break;
            	    case 3 :
            	        // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:20:38: removed_line
            	        {
            	        	PushFollow(FOLLOW_removed_line_in_line147);
            	        	removed_line();
            	        	state.followingStackPointer--;


            	        }
            	        break;
            	    case 4 :
            	        // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:20:53: no_newline
            	        {
            	        	PushFollow(FOLLOW_no_newline_in_line151);
            	        	no_newline();
            	        	state.followingStackPointer--;


            	        }
            	        break;

            	}

            	Match(input,CRLF,FOLLOW_CRLF_in_line154); 

            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return ;
    }
    // $ANTLR end "line"


    // $ANTLR start "context_line"
    // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:21:1: context_line : SPACE line_content ;
    public void context_line() // throws RecognitionException [1]
    {   
        diffParser.line_content_return line_content2 = default(diffParser.line_content_return);


        try 
    	{
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:21:14: ( SPACE line_content )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:21:16: SPACE line_content
            {
            	Match(input,SPACE,FOLLOW_SPACE_in_context_line161); 
            	PushFollow(FOLLOW_line_content_in_context_line163);
            	line_content2 = line_content();
            	state.followingStackPointer--;

            	proc.ContextLineHandler(((line_content2 != null) ? input.ToString((IToken)(line_content2.Start),(IToken)(line_content2.Stop)) : null));

            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return ;
    }
    // $ANTLR end "context_line"


    // $ANTLR start "added_line"
    // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:22:1: added_line : PLUS line_content ;
    public void added_line() // throws RecognitionException [1]
    {   
        diffParser.line_content_return line_content3 = default(diffParser.line_content_return);


        try 
    	{
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:22:12: ( PLUS line_content )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:22:14: PLUS line_content
            {
            	Match(input,PLUS,FOLLOW_PLUS_in_added_line172); 
            	PushFollow(FOLLOW_line_content_in_added_line174);
            	line_content3 = line_content();
            	state.followingStackPointer--;

            	proc.AddedLineHandler(((line_content3 != null) ? input.ToString((IToken)(line_content3.Start),(IToken)(line_content3.Stop)) : null));

            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return ;
    }
    // $ANTLR end "added_line"


    // $ANTLR start "removed_line"
    // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:23:1: removed_line : MINUS line_content ;
    public void removed_line() // throws RecognitionException [1]
    {   
        diffParser.line_content_return line_content4 = default(diffParser.line_content_return);


        try 
    	{
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:23:14: ( MINUS line_content )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:23:16: MINUS line_content
            {
            	Match(input,MINUS,FOLLOW_MINUS_in_removed_line183); 
            	PushFollow(FOLLOW_line_content_in_removed_line185);
            	line_content4 = line_content();
            	state.followingStackPointer--;

            	proc.DeletedLineHandler(((line_content4 != null) ? input.ToString((IToken)(line_content4.Start),(IToken)(line_content4.Stop)) : null));

            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return ;
    }
    // $ANTLR end "removed_line"


    // $ANTLR start "no_newline"
    // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:24:1: no_newline : NNL ;
    public void no_newline() // throws RecognitionException [1]
    {   
        try 
    	{
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:24:13: ( NNL )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:24:15: NNL
            {
            	Match(input,NNL,FOLLOW_NNL_in_no_newline195); 

            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return ;
    }
    // $ANTLR end "no_newline"

    public class line_content_return : ParserRuleReturnScope
    {
    };

    // $ANTLR start "line_content"
    // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:26:1: line_content : ( anytoken )* ;
    public diffParser.line_content_return line_content() // throws RecognitionException [1]
    {   
        diffParser.line_content_return retval = new diffParser.line_content_return();
        retval.Start = input.LT(1);

        try 
    	{
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:26:14: ( ( anytoken )* )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:26:16: ( anytoken )*
            {
            	// C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:26:16: ( anytoken )*
            	do 
            	{
            	    int alt9 = 2;
            	    int LA9_0 = input.LA(1);

            	    if ( ((LA9_0 >= INDEX && LA9_0 <= SPACE) || (LA9_0 >= SEPARATOR && LA9_0 <= CHAR)) )
            	    {
            	        alt9 = 1;
            	    }


            	    switch (alt9) 
            		{
            			case 1 :
            			    // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:26:16: anytoken
            			    {
            			    	PushFollow(FOLLOW_anytoken_in_line_content203);
            			    	anytoken();
            			    	state.followingStackPointer--;


            			    }
            			    break;

            			default:
            			    goto loop9;
            	    }
            	} while (true);

            	loop9:
            		;	// Stops C# compiler whining that label 'loop9' has no statements


            }

            retval.Stop = input.LT(-1);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "line_content"


    // $ANTLR start "hunk_header"
    // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:28:1: hunk_header : ATS SPACE MINUS range SPACE PLUS range SPACE ATS CRLF ;
    public void hunk_header() // throws RecognitionException [1]
    {   
        try 
    	{
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:28:13: ( ATS SPACE MINUS range SPACE PLUS range SPACE ATS CRLF )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:28:15: ATS SPACE MINUS range SPACE PLUS range SPACE ATS CRLF
            {
            	Match(input,ATS,FOLLOW_ATS_in_hunk_header212); 
            	Match(input,SPACE,FOLLOW_SPACE_in_hunk_header214); 
            	Match(input,MINUS,FOLLOW_MINUS_in_hunk_header216); 
            	PushFollow(FOLLOW_range_in_hunk_header218);
            	range();
            	state.followingStackPointer--;

            	oldRange=curRange;
            	Match(input,SPACE,FOLLOW_SPACE_in_hunk_header222); 
            	Match(input,PLUS,FOLLOW_PLUS_in_hunk_header224); 
            	PushFollow(FOLLOW_range_in_hunk_header226);
            	range();
            	state.followingStackPointer--;

            	newRange=curRange;
            	Match(input,SPACE,FOLLOW_SPACE_in_hunk_header230); 
            	Match(input,ATS,FOLLOW_ATS_in_hunk_header232); 
            	Match(input,CRLF,FOLLOW_CRLF_in_hunk_header234); 
            	proc.HunkStartHandler(oldFileName, oldRange, newFileName, newRange);

            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return ;
    }
    // $ANTLR end "hunk_header"


    // $ANTLR start "range"
    // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:30:1: range : b= number COMMA e= number ;
    public void range() // throws RecognitionException [1]
    {   
        diffParser.number_return b = default(diffParser.number_return);

        diffParser.number_return e = default(diffParser.number_return);


        try 
    	{
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:30:8: (b= number COMMA e= number )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:30:10: b= number COMMA e= number
            {
            	PushFollow(FOLLOW_number_in_range249);
            	b = number();
            	state.followingStackPointer--;

            	Match(input,COMMA,FOLLOW_COMMA_in_range251); 
            	PushFollow(FOLLOW_number_in_range255);
            	e = number();
            	state.followingStackPointer--;

            	curRange=new Range(){StartLine=ulong.Parse(((b != null) ? input.ToString((IToken)(b.Start),(IToken)(b.Stop)) : null)), EndLine=ulong.Parse(((e != null) ? input.ToString((IToken)(e.Start),(IToken)(e.Stop)) : null))};

            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return ;
    }
    // $ANTLR end "range"


    // $ANTLR start "cannot_display"
    // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:33:1: cannot_display : CD CRLF line_content CRLF ;
    public void cannot_display() // throws RecognitionException [1]
    {   
        try 
    	{
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:33:16: ( CD CRLF line_content CRLF )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:33:18: CD CRLF line_content CRLF
            {
            	Match(input,CD,FOLLOW_CD_in_cannot_display269); 
            	Match(input,CRLF,FOLLOW_CRLF_in_cannot_display271); 
            	PushFollow(FOLLOW_line_content_in_cannot_display273);
            	line_content();
            	state.followingStackPointer--;

            	Match(input,CRLF,FOLLOW_CRLF_in_cannot_display277); 

            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return ;
    }
    // $ANTLR end "cannot_display"


    // $ANTLR start "file_header"
    // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:35:1: file_header : rem SPACE firstPath= path rev CRLF add SPACE secondPath= path rev CRLF ;
    public void file_header() // throws RecognitionException [1]
    {   
        diffParser.path_return firstPath = default(diffParser.path_return);

        diffParser.path_return secondPath = default(diffParser.path_return);


        try 
    	{
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:35:13: ( rem SPACE firstPath= path rev CRLF add SPACE secondPath= path rev CRLF )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:35:15: rem SPACE firstPath= path rev CRLF add SPACE secondPath= path rev CRLF
            {
            	PushFollow(FOLLOW_rem_in_file_header285);
            	rem();
            	state.followingStackPointer--;

            	Match(input,SPACE,FOLLOW_SPACE_in_file_header287); 
            	PushFollow(FOLLOW_path_in_file_header291);
            	firstPath = path();
            	state.followingStackPointer--;

            	oldFileName = ((firstPath != null) ? input.ToString((IToken)(firstPath.Start),(IToken)(firstPath.Stop)) : null);
            	PushFollow(FOLLOW_rev_in_file_header295);
            	rev();
            	state.followingStackPointer--;

            	Match(input,CRLF,FOLLOW_CRLF_in_file_header297); 
            	PushFollow(FOLLOW_add_in_file_header303);
            	add();
            	state.followingStackPointer--;

            	Match(input,SPACE,FOLLOW_SPACE_in_file_header305); 
            	PushFollow(FOLLOW_path_in_file_header309);
            	secondPath = path();
            	state.followingStackPointer--;

            	newFileName = ((secondPath != null) ? input.ToString((IToken)(secondPath.Start),(IToken)(secondPath.Stop)) : null);
            	PushFollow(FOLLOW_rev_in_file_header313);
            	rev();
            	state.followingStackPointer--;

            	Match(input,CRLF,FOLLOW_CRLF_in_file_header315); 

            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return ;
    }
    // $ANTLR end "file_header"


    // $ANTLR start "add"
    // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:37:1: add : PLUS PLUS PLUS ;
    public void add() // throws RecognitionException [1]
    {   
        try 
    	{
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:37:6: ( PLUS PLUS PLUS )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:37:8: PLUS PLUS PLUS
            {
            	Match(input,PLUS,FOLLOW_PLUS_in_add323); 
            	Match(input,PLUS,FOLLOW_PLUS_in_add325); 
            	Match(input,PLUS,FOLLOW_PLUS_in_add327); 

            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return ;
    }
    // $ANTLR end "add"


    // $ANTLR start "rem"
    // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:38:1: rem : MINUS MINUS MINUS ;
    public void rem() // throws RecognitionException [1]
    {   
        try 
    	{
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:38:6: ( MINUS MINUS MINUS )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:38:8: MINUS MINUS MINUS
            {
            	Match(input,MINUS,FOLLOW_MINUS_in_rem335); 
            	Match(input,MINUS,FOLLOW_MINUS_in_rem337); 
            	Match(input,MINUS,FOLLOW_MINUS_in_rem339); 

            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return ;
    }
    // $ANTLR end "rem"

    public class path_return : ParserRuleReturnScope
    {
    };

    // $ANTLR start "path"
    // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:39:1: path : ( anytoken )+ ;
    public diffParser.path_return path() // throws RecognitionException [1]
    {   
        diffParser.path_return retval = new diffParser.path_return();
        retval.Start = input.LT(1);

        try 
    	{
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:39:7: ( ( anytoken )+ )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:39:9: ( anytoken )+
            {
            	// C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:39:9: ( anytoken )+
            	int cnt10 = 0;
            	do 
            	{
            	    int alt10 = 2;
            	    alt10 = dfa10.Predict(input);
            	    switch (alt10) 
            		{
            			case 1 :
            			    // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:39:9: anytoken
            			    {
            			    	PushFollow(FOLLOW_anytoken_in_path347);
            			    	anytoken();
            			    	state.followingStackPointer--;


            			    }
            			    break;

            			default:
            			    if ( cnt10 >= 1 ) goto loop10;
            		            EarlyExitException eee10 =
            		                new EarlyExitException(10, input);
            		            throw eee10;
            	    }
            	    cnt10++;
            	} while (true);

            	loop10:
            		;	// Stops C# compiler whining that label 'loop10' has no statements


            }

            retval.Stop = input.LT(-1);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "path"


    // $ANTLR start "rev"
    // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:40:1: rev : TAB ( LB REVISION SPACE ( ( DIGIT )+ ) RB | LB WORKING_COPY RB ) ;
    public void rev() // throws RecognitionException [1]
    {   
        try 
    	{
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:40:6: ( TAB ( LB REVISION SPACE ( ( DIGIT )+ ) RB | LB WORKING_COPY RB ) )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:40:8: TAB ( LB REVISION SPACE ( ( DIGIT )+ ) RB | LB WORKING_COPY RB )
            {
            	Match(input,TAB,FOLLOW_TAB_in_rev356); 
            	// C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:40:11: ( LB REVISION SPACE ( ( DIGIT )+ ) RB | LB WORKING_COPY RB )
            	int alt12 = 2;
            	int LA12_0 = input.LA(1);

            	if ( (LA12_0 == LB) )
            	{
            	    int LA12_1 = input.LA(2);

            	    if ( (LA12_1 == REVISION) )
            	    {
            	        alt12 = 1;
            	    }
            	    else if ( (LA12_1 == WORKING_COPY) )
            	    {
            	        alt12 = 2;
            	    }
            	    else 
            	    {
            	        NoViableAltException nvae_d12s1 =
            	            new NoViableAltException("", 12, 1, input);

            	        throw nvae_d12s1;
            	    }
            	}
            	else 
            	{
            	    NoViableAltException nvae_d12s0 =
            	        new NoViableAltException("", 12, 0, input);

            	    throw nvae_d12s0;
            	}
            	switch (alt12) 
            	{
            	    case 1 :
            	        // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:40:12: LB REVISION SPACE ( ( DIGIT )+ ) RB
            	        {
            	        	Match(input,LB,FOLLOW_LB_in_rev358); 
            	        	Match(input,REVISION,FOLLOW_REVISION_in_rev360); 
            	        	Match(input,SPACE,FOLLOW_SPACE_in_rev362); 
            	        	// C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:40:30: ( ( DIGIT )+ )
            	        	// C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:40:31: ( DIGIT )+
            	        	{
            	        		// C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:40:31: ( DIGIT )+
            	        		int cnt11 = 0;
            	        		do 
            	        		{
            	        		    int alt11 = 2;
            	        		    int LA11_0 = input.LA(1);

            	        		    if ( (LA11_0 == DIGIT) )
            	        		    {
            	        		        alt11 = 1;
            	        		    }


            	        		    switch (alt11) 
            	        			{
            	        				case 1 :
            	        				    // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:40:31: DIGIT
            	        				    {
            	        				    	Match(input,DIGIT,FOLLOW_DIGIT_in_rev365); 

            	        				    }
            	        				    break;

            	        				default:
            	        				    if ( cnt11 >= 1 ) goto loop11;
            	        			            EarlyExitException eee11 =
            	        			                new EarlyExitException(11, input);
            	        			            throw eee11;
            	        		    }
            	        		    cnt11++;
            	        		} while (true);

            	        		loop11:
            	        			;	// Stops C# compiler whining that label 'loop11' has no statements


            	        	}

            	        	Match(input,RB,FOLLOW_RB_in_rev370); 

            	        }
            	        break;
            	    case 2 :
            	        // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:40:45: LB WORKING_COPY RB
            	        {
            	        	Match(input,LB,FOLLOW_LB_in_rev374); 
            	        	Match(input,WORKING_COPY,FOLLOW_WORKING_COPY_in_rev376); 
            	        	Match(input,RB,FOLLOW_RB_in_rev378); 

            	        }
            	        break;

            	}


            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return ;
    }
    // $ANTLR end "rev"

    public class number_return : ParserRuleReturnScope
    {
    };

    // $ANTLR start "number"
    // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:42:1: number : ( DIGIT )+ ;
    public diffParser.number_return number() // throws RecognitionException [1]
    {   
        diffParser.number_return retval = new diffParser.number_return();
        retval.Start = input.LT(1);

        try 
    	{
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:42:9: ( ( DIGIT )+ )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:42:11: ( DIGIT )+
            {
            	// C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:42:11: ( DIGIT )+
            	int cnt13 = 0;
            	do 
            	{
            	    int alt13 = 2;
            	    int LA13_0 = input.LA(1);

            	    if ( (LA13_0 == DIGIT) )
            	    {
            	        alt13 = 1;
            	    }


            	    switch (alt13) 
            		{
            			case 1 :
            			    // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:42:11: DIGIT
            			    {
            			    	Match(input,DIGIT,FOLLOW_DIGIT_in_number389); 

            			    }
            			    break;

            			default:
            			    if ( cnt13 >= 1 ) goto loop13;
            		            EarlyExitException eee13 =
            		                new EarlyExitException(13, input);
            		            throw eee13;
            	    }
            	    cnt13++;
            	} while (true);

            	loop13:
            		;	// Stops C# compiler whining that label 'loop13' has no statements


            }

            retval.Stop = input.LT(-1);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "number"


    // $ANTLR start "anytoken"
    // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:44:1: anytoken : ( NNL | CD | REVISION | WORKING_COPY | PROP_CH | SEPARATOR | PROP_SEP | INDEX | SPACE | TAB | PLUS | MINUS | ATS | COMMA | LB | RB | DIGIT | CHAR ) ;
    public void anytoken() // throws RecognitionException [1]
    {   
        try 
    	{
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:44:10: ( ( NNL | CD | REVISION | WORKING_COPY | PROP_CH | SEPARATOR | PROP_SEP | INDEX | SPACE | TAB | PLUS | MINUS | ATS | COMMA | LB | RB | DIGIT | CHAR ) )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:44:12: ( NNL | CD | REVISION | WORKING_COPY | PROP_CH | SEPARATOR | PROP_SEP | INDEX | SPACE | TAB | PLUS | MINUS | ATS | COMMA | LB | RB | DIGIT | CHAR )
            {
            	if ( (input.LA(1) >= INDEX && input.LA(1) <= SPACE) || (input.LA(1) >= SEPARATOR && input.LA(1) <= CHAR) ) 
            	{
            	    input.Consume();
            	    state.errorRecovery = false;
            	}
            	else 
            	{
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    throw mse;
            	}


            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return ;
    }
    // $ANTLR end "anytoken"


    // $ANTLR start "nonindex"
    // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:45:1: nonindex : ( NNL | CD | REVISION | WORKING_COPY | PROP_CH | SEPARATOR | PROP_SEP | SPACE | TAB | PLUS | MINUS | ATS | COMMA | LB | RB | DIGIT | CHAR ) ;
    public void nonindex() // throws RecognitionException [1]
    {   
        try 
    	{
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:45:10: ( ( NNL | CD | REVISION | WORKING_COPY | PROP_CH | SEPARATOR | PROP_SEP | SPACE | TAB | PLUS | MINUS | ATS | COMMA | LB | RB | DIGIT | CHAR ) )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:45:12: ( NNL | CD | REVISION | WORKING_COPY | PROP_CH | SEPARATOR | PROP_SEP | SPACE | TAB | PLUS | MINUS | ATS | COMMA | LB | RB | DIGIT | CHAR )
            {
            	if ( input.LA(1) == SPACE || (input.LA(1) >= SEPARATOR && input.LA(1) <= CHAR) ) 
            	{
            	    input.Consume();
            	    state.errorRecovery = false;
            	}
            	else 
            	{
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    throw mse;
            	}


            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return ;
    }
    // $ANTLR end "nonindex"

    // Delegated rules


   	protected DFA10 dfa10;
	private void InitializeCyclicDFAs()
	{
    	this.dfa10 = new DFA10(this);
	}

    const string DFA10_eotS =
        "\x0c\uffff";
    const string DFA10_eofS =
        "\x0c\uffff";
    const string DFA10_minS =
        "\x01\x04\x01\uffff\x01\x04\x01\uffff\x06\x04\x01\x07\x01\x04";
    const string DFA10_maxS =
        "\x01\x16\x01\uffff\x01\x16\x01\uffff\x06\x16\x01\x0d\x01\x16";
    const string DFA10_acceptS =
        "\x01\uffff\x01\x02\x01\uffff\x01\x01\x08\uffff";
    const string DFA10_specialS =
        "\x0c\uffff}>";
    static readonly string[] DFA10_transitionS = {
            "\x02\x03\x01\x01\x09\x03\x01\x02\x06\x03",
            "",
            "\x0d\x03\x01\x04\x05\x03",
            "",
            "\x0e\x03\x01\x05\x02\x03\x01\x06\x01\x03",
            "\x01\x03\x01\x07\x11\x03",
            "\x10\x03\x01\x08\x02\x03",
            "\x0f\x03\x01\x09\x03\x03",
            "\x02\x03\x01\x0a\x10\x03",
            "\x0f\x03\x01\x09\x01\x0b\x02\x03",
            "\x01\x03\x01\uffff\x01\x03\x01\x01\x02\uffff\x01\x01",
            "\x02\x03\x01\x0a\x10\x03"
    };

    static readonly short[] DFA10_eot = DFA.UnpackEncodedString(DFA10_eotS);
    static readonly short[] DFA10_eof = DFA.UnpackEncodedString(DFA10_eofS);
    static readonly char[] DFA10_min = DFA.UnpackEncodedStringToUnsignedChars(DFA10_minS);
    static readonly char[] DFA10_max = DFA.UnpackEncodedStringToUnsignedChars(DFA10_maxS);
    static readonly short[] DFA10_accept = DFA.UnpackEncodedString(DFA10_acceptS);
    static readonly short[] DFA10_special = DFA.UnpackEncodedString(DFA10_specialS);
    static readonly short[][] DFA10_transition = DFA.UnpackEncodedStringArray(DFA10_transitionS);

    protected class DFA10 : DFA
    {
        public DFA10(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 10;
            this.eot = DFA10_eot;
            this.eof = DFA10_eof;
            this.min = DFA10_min;
            this.max = DFA10_max;
            this.accept = DFA10_accept;
            this.special = DFA10_special;
            this.transition = DFA10_transition;

        }

        override public string Description
        {
            get { return "()+ loopback of 39:9: ( anytoken )+"; }
        }

    }

 

    public static readonly BitSet FOLLOW_file_in_diff34 = new BitSet(new ulong[]{0x0000000000000052UL});
    public static readonly BitSet FOLLOW_prop_in_diff36 = new BitSet(new ulong[]{0x0000000000000052UL});
    public static readonly BitSet FOLLOW_INDEX_in_file47 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_SPACE_in_file49 = new BitSet(new ulong[]{0x00000000007FFFB0UL});
    public static readonly BitSet FOLLOW_path_in_file51 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_CRLF_in_file55 = new BitSet(new ulong[]{0x0000000000000080UL});
    public static readonly BitSet FOLLOW_SEPARATOR_in_file57 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_CRLF_in_file59 = new BitSet(new ulong[]{0x0000000000008800UL});
    public static readonly BitSet FOLLOW_file_header_in_file68 = new BitSet(new ulong[]{0x0000000000002000UL});
    public static readonly BitSet FOLLOW_hunk_in_file70 = new BitSet(new ulong[]{0x0000000000002002UL});
    public static readonly BitSet FOLLOW_cannot_display_in_file76 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_CRLF_in_prop90 = new BitSet(new ulong[]{0x0000000000000100UL});
    public static readonly BitSet FOLLOW_PROP_CH_in_prop92 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_SPACE_in_prop94 = new BitSet(new ulong[]{0x00000000007FFFB0UL});
    public static readonly BitSet FOLLOW_path_in_prop96 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_CRLF_in_prop98 = new BitSet(new ulong[]{0x0000000000000200UL});
    public static readonly BitSet FOLLOW_PROP_SEP_in_prop100 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_CRLF_in_prop102 = new BitSet(new ulong[]{0x00000000007FFFE0UL});
    public static readonly BitSet FOLLOW_nonindex_in_prop106 = new BitSet(new ulong[]{0x00000000007FFFF0UL});
    public static readonly BitSet FOLLOW_anytoken_in_prop108 = new BitSet(new ulong[]{0x00000000007FFFF0UL});
    public static readonly BitSet FOLLOW_CRLF_in_prop111 = new BitSet(new ulong[]{0x00000000007FFFE0UL});
    public static readonly BitSet FOLLOW_CRLF_in_prop115 = new BitSet(new ulong[]{0x0000000000000042UL});
    public static readonly BitSet FOLLOW_hunk_header_in_hunk124 = new BitSet(new ulong[]{0x0000000000001C20UL});
    public static readonly BitSet FOLLOW_line_in_hunk126 = new BitSet(new ulong[]{0x0000000000001C22UL});
    public static readonly BitSet FOLLOW_context_line_in_line139 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_added_line_in_line143 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_removed_line_in_line147 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_no_newline_in_line151 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_CRLF_in_line154 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_SPACE_in_context_line161 = new BitSet(new ulong[]{0x00000000007FFFB0UL});
    public static readonly BitSet FOLLOW_line_content_in_context_line163 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_PLUS_in_added_line172 = new BitSet(new ulong[]{0x00000000007FFFB0UL});
    public static readonly BitSet FOLLOW_line_content_in_added_line174 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_MINUS_in_removed_line183 = new BitSet(new ulong[]{0x00000000007FFFB0UL});
    public static readonly BitSet FOLLOW_line_content_in_removed_line185 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_NNL_in_no_newline195 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_anytoken_in_line_content203 = new BitSet(new ulong[]{0x00000000007FFFB2UL});
    public static readonly BitSet FOLLOW_ATS_in_hunk_header212 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_SPACE_in_hunk_header214 = new BitSet(new ulong[]{0x0000000000000800UL});
    public static readonly BitSet FOLLOW_MINUS_in_hunk_header216 = new BitSet(new ulong[]{0x0000000000080000UL});
    public static readonly BitSet FOLLOW_range_in_hunk_header218 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_SPACE_in_hunk_header222 = new BitSet(new ulong[]{0x0000000000000400UL});
    public static readonly BitSet FOLLOW_PLUS_in_hunk_header224 = new BitSet(new ulong[]{0x0000000000080000UL});
    public static readonly BitSet FOLLOW_range_in_hunk_header226 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_SPACE_in_hunk_header230 = new BitSet(new ulong[]{0x0000000000002000UL});
    public static readonly BitSet FOLLOW_ATS_in_hunk_header232 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_CRLF_in_hunk_header234 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_number_in_range249 = new BitSet(new ulong[]{0x0000000000004000UL});
    public static readonly BitSet FOLLOW_COMMA_in_range251 = new BitSet(new ulong[]{0x0000000000080000UL});
    public static readonly BitSet FOLLOW_number_in_range255 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_CD_in_cannot_display269 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_CRLF_in_cannot_display271 = new BitSet(new ulong[]{0x00000000007FFFF0UL});
    public static readonly BitSet FOLLOW_line_content_in_cannot_display273 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_CRLF_in_cannot_display277 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_rem_in_file_header285 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_SPACE_in_file_header287 = new BitSet(new ulong[]{0x00000000007FFFB0UL});
    public static readonly BitSet FOLLOW_path_in_file_header291 = new BitSet(new ulong[]{0x0000000000010000UL});
    public static readonly BitSet FOLLOW_rev_in_file_header295 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_CRLF_in_file_header297 = new BitSet(new ulong[]{0x0000000000000400UL});
    public static readonly BitSet FOLLOW_add_in_file_header303 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_SPACE_in_file_header305 = new BitSet(new ulong[]{0x00000000007FFFB0UL});
    public static readonly BitSet FOLLOW_path_in_file_header309 = new BitSet(new ulong[]{0x0000000000010000UL});
    public static readonly BitSet FOLLOW_rev_in_file_header313 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_CRLF_in_file_header315 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_PLUS_in_add323 = new BitSet(new ulong[]{0x0000000000000400UL});
    public static readonly BitSet FOLLOW_PLUS_in_add325 = new BitSet(new ulong[]{0x0000000000000400UL});
    public static readonly BitSet FOLLOW_PLUS_in_add327 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_MINUS_in_rem335 = new BitSet(new ulong[]{0x0000000000000800UL});
    public static readonly BitSet FOLLOW_MINUS_in_rem337 = new BitSet(new ulong[]{0x0000000000000800UL});
    public static readonly BitSet FOLLOW_MINUS_in_rem339 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_anytoken_in_path347 = new BitSet(new ulong[]{0x00000000007FFFB2UL});
    public static readonly BitSet FOLLOW_TAB_in_rev356 = new BitSet(new ulong[]{0x0000000000020000UL});
    public static readonly BitSet FOLLOW_LB_in_rev358 = new BitSet(new ulong[]{0x0000000000040000UL});
    public static readonly BitSet FOLLOW_REVISION_in_rev360 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_SPACE_in_rev362 = new BitSet(new ulong[]{0x0000000000080000UL});
    public static readonly BitSet FOLLOW_DIGIT_in_rev365 = new BitSet(new ulong[]{0x0000000000180000UL});
    public static readonly BitSet FOLLOW_RB_in_rev370 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_LB_in_rev374 = new BitSet(new ulong[]{0x0000000000200000UL});
    public static readonly BitSet FOLLOW_WORKING_COPY_in_rev376 = new BitSet(new ulong[]{0x0000000000100000UL});
    public static readonly BitSet FOLLOW_RB_in_rev378 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_DIGIT_in_number389 = new BitSet(new ulong[]{0x0000000000080002UL});
    public static readonly BitSet FOLLOW_set_in_anytoken398 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_set_in_nonindex441 = new BitSet(new ulong[]{0x0000000000000002UL});

}
}